Mengukur Jarak Data¶
Mengukur Tipe Jarak Numerik¶
Data Numerik adalah data yang merupakan hasil dari pengukuran . Maka hasil dari dari numerical data itu adalah data murni yang dihasilkan dari penelitian tiap orang untuk mengukur data-data yang nanti dihasilkan melalui data yang telah diperoleh dari pengukuran data keseluruhan. Dalam era modern ini kita sudah mengenali data base (data mining ) yang memiliki banyak tipe data yang digunakan untuk bisa mengukur jarak tiap data data tersebut .
Cara Menghitung setiap ukuran jarak dengan Tipe Numerik yang dibedakan dalam berbagai macam,yaitu diantaranya :¶
Minkowski Distance¶
Minkowski Distance adalah matriks dalam Ruang vektor normed yang dapat dianggap sebagai generalisasi dari Ecludian Distance dan Manhattan Distance. Dapat dirumuskan sebagai berikut : $$ d _ { \operatorname { min } } = ( \ sum _ { i = 1 } ^ { n } | x _ { i } - y _ { i } | ^ { m } ) ^ { \frac { 1 } { m } } , m \geq 1 $$
Dimana m adalah bilangan real positif Xi dan Yi adalah dua vektor yang dalam ruang dimensi n yang diemplementasikan untuk mengukur jarak Minkowski Distance pada model clustering data pada atribut yang telah diketahui untuk bisa melakukan normalisasi dan menghindari dominasi dari atribut yang memiliki data skala besar.
Manhattan Distance¶
Manhattan Distance adalah kasus khusus dari jarak Minkowsi distance pada m = 1 . Seperti Minkowski Distance , Manhattan Distance sensitif terhadap outlier. Tetapi jika digunakan dalam algoritma clustering, bentuk cluster adalah hyper-rectangular. Ukuran inilah yang didefinisikan sebagai rumus berikut : $$ d_{\operatorname{man}}= \sum_{i=1}^{n} \left | x_{i} - y {i}\right| $$
Euclidean Distance¶
Jarak yang sering digunakan dan dikenal untuk data tipe numerik adalah menggunakan jarak Euclidean ini. Jarak euclidean ini adalah kasus khusus dari Jarak Minkowski distance ketika m = 2. Euclidean distance berkinerja baik ketika digunakan untuk bisa mengumpulkan data cluster kompak atau terisolasi. Meskipun jarak Eucldian ini sangat umum dalam pengolompokan, ia memiliki kelemahan,yaitu : jka dua vektor data tidak memiliki nilai atribut yang sama, kemungkinan memiliki jarak yang lebih kecil daripada pasangan vektor data lainnya yang mengandung nilai atribut yang sama. Masalah lain jika menggunakan jarak Euclidean sebagai fitur skala terbesar akan mendominasi yang lain. Normalisasi fitur kontinu adalah solusi untuk mengatas kelemahan ini.
Average Distance¶
Dengan jarak averange ini memiliki kekurangan dari Jarak Euclidean diatas, rata-rata jarak adalah versi modifikasi dari Jarak Euclidean untuk memperbaiki hasil. Untuk dua titik x, y dalam ruang dimensi n , rata-rata jarak didefinisikan sebagai berikut : $$ d _ { a v e } = \left ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } ( x _ { i } - y _ { i } ) ^ { 2 } \right) ^ { \frac { 1 } { 2 } } $$
Weighted Euclidean¶
Ini adalah modifikasi lain dari Jarak Euclidean Distance yang memiliki tingkatan penting dari masing-masing atribut yang telah ditentukan. Dapat definisikan sebagai berikut dengan rumus : $$ d _ { w e } = \left ( \sum _ { i = 1 } ^ { n } w _ { i } ( x _ { i } - y _ { i } \right) ^ { 2 } ) ^ { \frac { 1 } { 2 } } $$ Dimana Wi tersebut adalah bobot yang diberikan pada atribut ke i.
Chord Distance¶
Chord Distance ini adalah suatu jarak yang telah dimodifikasi dari jarak Euclidean distance untuk bisa mengatasi kekurangan yang ada pada Euclidean distance. InI dapat dipecahkan juga dengan menggunakan skala pengukuran yang baik. Serta jarak ini juga dapat dihitung dari data yang tidak dinormalisasi. Chord Distance ini dapat didefinisikan sebagai berikut : $$ d _ { \text {chord} } = \left ( 2 - 2 \frac { \sum _ { i = 1 } ^ { n } x _ { i } y _ { i } } { | x | _ { 2 } | y | _ { 2 } } \right) ^ { \frac { 1 } { 2 } } $$ Dimana : $$ Dimana \quad ||x||_2 \quad adalah \quad L^2-norm||x||_2 =\sqrt{ \sum _ { i = 1 } ^ { n } x _ { i }^2} $$
Mahalanobis Distance¶
Mahalanobis Distance berdasarkan data berbeda dengan kedua jarak yaitu Euclidean dan Manhattan distances, yang bebas antara data dengan data yang lain. Jarak Mahalanobis yang teratur dapat digunakan untuk mengekstraksi hyperellipsoidal cluster. Jarak Mahalanobis dapat mengurangi distorsi yang disebabkan oleh korelasi liner antara fitur dengan menerapkan suatu transformasi pemutihan ke data atau dengan menggunakan kudrat Jarak Mahalanobis. Mahalanobis dapat didefinisikan sebagai berikut : $$ d _ { m a h } = \sqrt { ( x - y ) S ^ { - 1 } ( x - y ) ^ { T } } $$ Dimana S sebagai matriks covariance data.
Cosine Measure¶
Ukururan Cosine banyak kesamaan yang digunakan dalam similaritas dokumen dan dinyatakan dengan $$ Cosine(x,y)=\frac { \sum _ { i = 1 } ^ { n } x _ { i } y _ { i } } { | x | _ { 2 } | y | _ { 2 } } $$
Pearson Correlation¶
Pearson correlation banyak digunakan dalam data ekspresi gen. Ukuran kesamaan ini menghitung similaritas antara dua bentuk pola ekspresi gen . Pearson correlation didefinisikan sebagai berikut : $$ Pearson ( x , y ) = \frac { \sum _ { i = 1 } ^ { n } ( x _ { i } - \mu _ { x } ) ( y _ { i } - \mu _ { y } ) } { \sqrt { \sum _ { i = 1 } ^ { n } ( x _ { i } - y _ { i } ) ^ { 2 } } \sqrt { \sum _ { i = 1 } ^ { n } ( x _ { i } - y _ { i } ) ^ { 2 } } } $$ Pada Jarak Pearson correlation ini memiliki kelamahan adalah sensitif terhadap outlier.
Mengukur Jarak Tipe Data Binary¶
Similirity dan desimilirty pada objek Biner ini dibedakan dalam 2 macam , yaitu atribut biner yang simetris dan asimetris. Atribut biner hanya memiliki 2 status 0 dan 1 contoh menggambar seseorang memiliki jenis kelamin dapat kita bedakan dengan pemisalan bahwa laki-laki menunjukkan 1 dan perempuan 0 karena dalam jenis kelamin hanya memiliki 2 status ,hal ini yang bisa kita sebut bahwa data ini disebut sebagai biner karena dengan membedakannya menggunakan 2 status tanpa adanya metode khusus untuk melakukan atribut biner sebagai atribut numerik. Oleh karena itu data biner dapat dibedakan dalam komputasi.
Hal tersebut disebut simetris karena tanpa menghitung kembali ketidaksamaan berbeda dengan asimetris. Bila asimetris kita perlu untuk menghitung ketidaksamaan antara dua atribut biner contoh dalam penghitungan data kehamilan ataupun data terkena penyakit HIV itu perlu kita hitung kembali dikarenakan meskipun itu data biner ,dalam data pastinya ada perhitungan misal dalam terkena penyakit HIV itu data hari pertama menunjukkan positif di hari selanjutnya bisa berbeda ,begitu pula dengan data kehamilan pada data pertama menunjukkan negatif dan data berikutnya menunjukkan positif maka kita bisa anggap bahwa asimetris ini perlunya melibatkan perhitungan matriks antara ketidaksamaan dari data biner yang diberikan. Jika semua atribut iner dianggap memilki bobot yang sama, kita memiliki tabel kontingensi 2 x 2 dimana q adalah jumlah atribut yang = 1 untuk kedua objek i dan j,r adalah jumlah atribut yang sama dengan 1 untuk objek I tetapi 0 untuk objek j, s adalah jumlah atribut yang sama dengan 0 untuk objek i tetapi 1 untuk objek j, dan t adalah jumlah atribut yang sama dengan 0 untuk kedua objek i dan j. Jumlah total atribut adalah p, di mana p = q + r +s +t
Atribut biner simetris, masing-masing memiliki nilai bobot yang sama. Dapat kita nyatakan sebagai Dissimilarity pada atribut yang disebut symmetric binary dissimilarity. Jika objek i dan j disebut sebagai atribut biner simetris pada rumus berikut : $$ d(i,j)=\frac {r+s}{q+r+s+t} $$ Untuk atribut biner asimetris, dua atribut biner asimetris perlu dilakukan pencocokan agar keduanya dapat diketahui bahwa 1 (kecocokan positif) dari pada 0(kecocokan negatif). Ketidaksamaan berdasarkan atribut ini disebut asimetris biner dissimilarity. Dimana dapat kita hitung dengan rumus berikut : $$ d(i,j)=\frac {r+s}{q+r+s} $$ Kita dapat mengukur perbedaan antara dua atribut biner berdasarkan pada disimilarity pada rumus berikut : $$ sim(i,j)=\frac {q}{q+r+s}=1-d(i,j) $$ Persamaan similarity diatas disebut dengan Jaccard Coefficient
Mengukur Jarak Tipe Data Kategorical¶
Overlay Metric¶
Saat semuat atribut adalah tipe data nominal, ukuran jarak yang paling sederhana dengan menggunakan Overlay Metric (OM) yang dinyatakan dengan $$ d ( x , y ) = \sum _ { i = 1 } ^ { n } \delta ( a _ { i } ( x ) , a _ { i } ( y ) ) $$ dimana n adalah banyaknya atribut, ai (x) dan ai(y) adalah atribut ke i yaitu Ai dari masing masing objek x dan y, Delta (ai(x)),ai(y)) adalah 0 jika ai(x)=ai(y) dan 1 jika sebaliknya.
OM banyak digunakan oleh instance-based learning dan locally weighted learning. Ada kegagalan memanfaatkan tambahan informasi yang diberikan oleh nilai atribut nominal yang bisa membantu dalam generalisasi
Value Difference Metric (VDM)¶
Versi sederhana dari VDM tanpa skema pembobotan dapat didefinisikan sebagai berikut : $$ d ( x , y ) = \sum _ { i = 1 } ^ { n } \sum _ { c = 1 } ^ { C } \left| P ( c | a _ { i } ( x ) ) - P ( c | a _ { i } ( y ) ) \right | $$
Minimum Risk Metric (MRM)¶
Ukuran ini dipresentasikan oleh Blanzieri dan Ricci, berbeda dari SFM yaitu meminimumkan selisih antara kesalahan berhingga dan kesalahan asymtotic. MRM meminimumkan risk of misclassfication (kegagalan dalam kesalahan klasifikasi) didefinisikan sebagai berikut : $$ d ( x , y ) = \sum _ { c = 1 } ^ { C } P ( c | x ) ( 1 - P ( c | y ) ) $$ Dimana C adalah banyaknya kelas
VDM mengamsusikan bahwa dua nilai dari atribut adalah lebih dekat jika memiliki klasifikasi yang sama. Pendekatan lain berbasis probabilitias adalah SFM (Short and Fukunaga Metric) yang kemudian dikembangkan oleh Myles and Hand didefinisikan sebagai berikut : $$ d ( x , y ) = \sum _ { c = 1 } ^ { C } \left | P ( c | x ) - P ( c | y ) \right| $$
Mengukur Jarak Tipe Ordinal¶
Nilai-nilai atribut ordinal dapat kita ketahui dari urutan atau peringkat, namum besarnya antara nilai-nilai berturut turut tidak diketahui. Contoh tingkatan tingkatan bawah, sedang, tinggi untuk atribut ukuran. Atribut ordinal juga dapat diperoleh dari diskritasi atribut numerik dengan membuat rentang nilai ke dalam sejumlah kategori tertentu. Kategori-kategori ini disusun dalam peringkat. Yaitu rentang atribut numerik dapat dipetakan ke atribut ordinal f yang Memiliki Mf state. M adalah jumlah keadaan yang dapat dilakukan oleh ordinal yang dimiliki atau bisa disebut sebagai banyaknya ordinal. rif sebagai ordinal yang akan dihitung. zif sebagai menormalisasikan data dengan menggantinya peringkatnya dengan rif,yaitu degan rumus berikut : $$ z _ { i f } = \frac { r _ { i f } - 1 } { M _ { f } - 1 } $$ setalah menghitung rumus diatas dan mendapat nilai dari zif itu ,menghitung jaraknya dengan tipe numerik yang akan digunakan.
Mengukur Jarak Tipe Campuran¶
Cara mengukurnya dengan menghitung ketidaksamaan antara objek dengan atribut tipe data campuran yang berupa nominal,biner simetris,biner asimetris,kategorical atau ordinal yang ada pada kebanyakan database dapat dinyatakan dalam semua tipe dengan melakukan proses normalisasi dengan tipe atribut secara bersamaan. Salah satunya dengan menggabungkan atribut yang berbeda dengan matriks ketidaksamaan tunggal dan menyatakannya dalam skala interval antar [0,0,1.0]. Misalkan data berisi atribut p tipe campuran. Disimilarity antara objek i dan j dinyatakan dengan : $$ d ( i , j ) = \frac { \sum _ { f = 1 } ^ { p } \delta _ { i j } ^ { ( f ) } d _ { i j } ^ { ( f ) } } { \sum _ { f = 1 } ^ { p } \delta _ { i j } ^ { ( f ) } } $$
Cara Menghitung Jarak Dengan Tipe Data Campuran Menggunakan Python¶
Langkah Pertama¶
Dengan menginstall pandas terlebih dahulu di cmd dengan pip install pandas. Bila telah di install masukkan kedalam code untuk bisa dibaca didalam program tersebut
import pandas as pd import math as mt from sklearn.preprocessing import LabelEncoder
Langkah Kedua¶
Memasukkan data csv. yang telah dibuat dalam tipe campuran dan dimasukkkan kedalam code untuk bisa dibaca didalam programnya
data = pd.read_csv("DataJrk1.csv",sep=';') df = pd.DataFrame(data) df.style.hide_index()
Maka akan tampil tabel yang ada didalam csv tersebut,sebagai berikut
| Nama | Jenis Kelamin | IPK | Penghasilan Orangtua | Alamat | Prestasi |
|---|---|---|---|---|---|
| Dani | L | 3.5 | 3000000 | Sumenep | Internasional |
| Risa | P | 3.3 | 5000000 | Sampang | Regional |
| Imam | L | 3.4 | 4000000 | Bangkalan | Nasional |
Langkah Ketiga¶
Langkah ini, menerapkan dari formula atau rumus yang telah dihitung untuk bisa menghitung jarak diatas yang menggunakan tipe data campuran, kita menghitungnya dalam bentuk fungsi python. Fungsi berikut digunakan untuk dinormalisasikan terbelebih dahulu untuk menjadi tipe data numerik.
def Zscore(x,mean,std): top = x - mean if top==0: return top else: return round(top / std, 2) def normalisasi(num, col_x): return Zscore(num, pd.Series(data[col_x].values).mean(), pd.Series(data[col_x].values).std())
Fungsi berikut untuk menghitung jarak tipe numerik dengan menerapkan rumus dari Euclidean Distance untuk menghitung jarak tersebut
#menghitung jarak tipe numerikal def euclidianDistance(x,y): dis = 0 for i in range(len(x)): dis += (x[i] - y[i]) ** 2 return round(mt.sqrt(dis),2)
Fungsi berikut untuk menghitung jarak pada tipe data binary simetris
#Menghitung jarak tipe binary def distanceSimetris(x,y): q=r=s=t=0 for i in range(len(x)): if x[i]==1 and y[i]==1: q+=1 elif x[i]==1 and y[i]==0: r+=1 elif x[i]==0 and y[i]==1: s+=1 elif x[i]==0 and y[i]==0: t+=1 return ((r+s)/(q+r+s+t))
Fungsi untuk menghitung jarak Tipe data Kategorikal
#Menghitung Jarak tipe categorikal def distanceNom(x,y): p = len(x) or len(y) m = 0 for i in range(len(x)): if x[i][0] == y[i][0]: m +=1 return (p - m) / p
Fungsi Selanjutnya dengan melakukan normalisasi pada tipe data ordinal
#Menghitung Jarak tipe ordinal #inisialisasi x = {'Internasional':3,'Nasional':2,'Regional':1} def normalizedOrd(y): i_max = 0 for i in x: if x[i] > i_max: i_max = x[i] if y[0] == i: i_val = x[i] return (i_val - 1) / (i_max - 1)
Langkah Keempat¶
Pada langkah ini kita membuat inisialisasi didictionary dengan disimilarity matrix:
d_x = { 0 : ['', 'Dani', 'Risa', 'Imam'], 1 : ['Dani', 0, '', ''], 2 : ['Risa', '', 0, ''], 3 : ['Imam', '', '', 0] }
Langkah Kelima¶
Untuk mempermudah menghitung jarak dari tipe data biner, kita bisa melakukan konversi nilai dari fitur tersebut dalam bentuk numerik atau angka 0 atau 1. Dalam pemprosesan konversi tersebut kita dapat menggunakan fungsi LabelEncode yang merupakan bawaan dari library sklearn
X = data.iloc[:,:].values labelEncode_X = LabelEncoder() X[:,1] = labelEncode_X.fit_transform(X[:,1])
Langkah Keenam¶
Pada Langkah ini kita menghitung jarak dari masing-masing tipe menggunaka fungsi yang telah dibuat sebelumnya
Menghitung Jarak Tipe Numerik¶
Berikut proses menghitung jarak dengan tipe numerik . Pada proses berikut kita mengambil fitur-fitur numerik dari masing-masing objek ,yaitu Dani,Risa dan Imam. Dari data numerik tersebut kemudian dinormalisasi dan menghitungnya dengan menggunakan fungsi Euclidean Distance yang hasilnya ditampung pada dictionary disimilarity matrix
#ambil data numerikal aliNum = df.iloc[0, 2:4].values aniNum = df.iloc[1, 2:4].values abiNum = df.iloc[2, 2:4].values #normalisasi data numerikal aliNum = [normalisasi(aliNum[0], data.columns[2]), normalisasi(aliNum[1], data.columns[3])] aniNum = [normalisasi(aniNum[0], data.columns[2]), normalisasi(aniNum[1], data.columns[3])] abiNum = [normalisasi(abiNum[0], data.columns[2]), normalisasi(abiNum[1], data.columns[3])] d_x[1][2] = euclidianDistance(aniNum,aliNum) d_x[1][3] = euclidianDistance(abiNum,aliNum) d_x[2][3] = euclidianDistance(abiNum,aniNum) d_x = pd.DataFrame(d_x) d_x.style.hide_index()
Dari proses diatas, akan menampilkan jarak dalam bentuk disimilarity matrix. Apabila disimilarity matrix mendekati0 maka kedua objek tersebut makin sama.
| 0 | 1 | 2 | 3 |
|---|---|---|---|
| Dani | Risa | Imam | |
| Dani | 0 | ||
| Risa | 2.83 | 0 | |
| Imam | 1.41 | 1.41 | 0 |
Menghitung Jarak Tipe Kategorikal¶
Proses berikut kita menghitung jarak dengan dengan tipe kategorikal/ nominal. Pada proses tersebut kita akan mengambil nilai dari fitur kategorikal dari masing-masing objek. Dalam kasus diatas kategorikal di atas adalah alamat yang beratas namakan tempat (Kabupaten). Selanjutnya nilai masing masing diambil dan dihitung menggunakan fungsi distanceNom(obj1,obj2) yang telah dibuat sebelumnya yaitu
#ambil data kategorical aliKat = [df.iloc[0, 4:5].values] aniKat = [df.iloc[1, 4:5].values] abiKat = [df.iloc[2, 4:5].values] d_x[1][2] = distanceNom(aniKat,aliKat) d_x[1][3] = distanceNom(abiKat,aliKat) d_x[2][3] = distanceNom(abiKat,aniKat) d_x = pd.DataFrame(d_x) d_x.style.hide_index()
| 0 | 1 | 2 | 3 |
|---|---|---|---|
| Dani | Risa | Imam | |
| Dani | 0 | ||
| Risa | 1 | 0 | |
| Imam | 1 | 1 | 0 |
Menghitung Jarak Tipe Binary¶
Proses berikut menghitung jarak tipe biner dengan mengambil nilai dari masing masing objek .Dalam kasus tadi pada fitur binary adalah Jenis Kelamin. Pada fungsi ini kita menggunakan rumus di dalam fungsi distanceSimetris(obj1,obj2). Dari hasil perhitungan bisa kita tampung di dictionary disimilarity matrix
#ambil data binary aliBin = X[0, 1:2] aniBin = X[1, 1:2] abiBin = X[2, 1:2] d_x[1][2] = distanceSimetris(aniBin,aliBin) d_x[1][3] = distanceSimetris(abiBin,aliBin) d_x[2][3] = distanceSimetris(abiBin,aniBin) d_x = pd.DataFrame(d_x) d_x.style.hide_index()
Dari proses diatas bisa kita tampilkan hasil running dari jarak yang telah dihitung
| 0 | 1 | 2 | 3 |
|---|---|---|---|
| Dani | Risa | Imam | |
| Dani | 0 | ||
| Risa | 1 | 0 | |
| Imam | 0 | 1 | 0 |
Menghitung Jarak Tipe Ordinal¶
Berikut kita menghitung jarak tipe ordinal dengan mengambil nilai dari masing masing objek diatas dari fitur Prestasi tingkatan objeknya. Nilai dari masing masing objek di normalisasi menggunakan fungsi normalizedOrd(ordObj)yang telah dibuat sebelumnya dengan menggunakan fungsi jarak euclideanDistance(obj1,obj2) yang hasilnya kemudian ditampung di dictionary similarity
#ambil data ordinal aliOrd = [df.iloc[0, 5:6].values] aniOrd = [df.iloc[1, 5:6].values] abiOrd = [df.iloc[2, 5:6].values] d_x[1][2] = euclidianDistance([normalizedOrd(aniOrd)],[normalizedOrd(aliOrd)]) d_x[1][3] = euclidianDistance([normalizedOrd(abiOrd)],[normalizedOrd(aliOrd)]) d_x[2][3] = euclidianDistance([normalizedOrd(abiOrd)],[normalizedOrd(aniOrd)]) d_x = pd.DataFrame(d_x) d_x.style.hide_index()
Dari proses diatas bisa kita tampilkan jarak dari ordinal ,sebagai berikut
| 0 | 1 | 2 | 3 |
|---|---|---|---|
| Dani | Risa | Imam | |
| Dani | 0 | ||
| Risa | 1 | 0 | |
| Imam | 0.5 | 0.5 | 0 |
Menghitung Jarak Tipe Campuran¶
Pada proses ini kita akan menghitung jarak dengan berbagai tipe . Untuk menghitungnya kita menjumlah jarak dari masing-masing tipe
d_x[1][2] = euclidianDistance(aniNum,aliNum) + \ distanceNom(aniKat,aliKat) + distanceSimetris(aniBin,aliBin) +\ euclidianDistance([normalizedOrd(aniOrd)],[normalizedOrd(aliOrd)]) d_x[1][3] = euclidianDistance(abiNum,aliNum) + \ distanceNom(abiKat,aliKat) + distanceSimetris(abiBin,aliBin) +\ euclidianDistance([normalizedOrd(abiOrd)],[normalizedOrd(aliOrd)]) d_x[2][3] = euclidianDistance(abiNum,aniNum) + \ distanceNom(abiKat,aniKat) + distanceSimetris(abiBin,aniBin) +\ euclidianDistance([normalizedOrd(abiOrd)],[normalizedOrd(aniOrd)]) d_x = pd.DataFrame(d_x) d_x.style.hide_index()
Dari proses diatas bisa kita tampilkan jarak dari berbagai tipe data ,sebagai berikut
| 0 | 1 | 2 | 3 |
|---|---|---|---|
| Dani | Risa | Imam | |
| Dani | 0 | ||
| Risa | 5.83 | 0 | |
| Imam | 2.91 | 3.91 | 0 |